﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using Scriptor.Presentation.Entity;
using Scriptor.Presentation.Enumerator;

namespace Scriptor.Presentation.Core
{
    public class DB
    {
        public DataSet   Authomat { get; set; }
        public DataTable Module { get; set; }
        public DataTable SubModule { get; set; }
        public DataTable Interface { get; set; }
        public DataTable Method { get; set; }
        public DataTable Return { get; set; }
        public DataTable Parameter { get; set; }

        //Tabelas Auxiliares Enum
        public DataTable Enums { get; set; }
        public DataTable ItensEnums { get; set; }

        //Tabelas Auxiliares Propriedades
        public DataTable Entidade { get; set; }
        public DataTable PropriedadesEntidade { get; set; }

        public void GenerateSchema()
        {
            Authomat = new DataSet();
            Module = new DataTable("Module");
            SubModule = new DataTable("SubModule");
            Interface = new DataTable("Interface");
            Method = new DataTable("Method");
            Return = new DataTable("Return");
            Parameter = new DataTable("Parameter");

            Authomat.Tables.Add(Module);
            Authomat.Tables.Add(SubModule);
            Authomat.Tables.Add(Interface);
            Authomat.Tables.Add(Method);
            Authomat.Tables.Add(Return);
            Authomat.Tables.Add(Parameter);

            //Module
            DataColumn IdModule = new DataColumn("IdModule");
            IdModule.DataType = typeof(System.Int32);
            Module.Columns.Add(IdModule);

            DataColumn descModule = new DataColumn("descModule");
            descModule.DataType = typeof(System.String);
            Module.Columns.Add(descModule);

            //SubModule
            DataColumn IdModuleInSubModule = new DataColumn("IdModuleInSubModule");
            IdModuleInSubModule.DataType = typeof(System.Int32);
            SubModule.Columns.Add(IdModuleInSubModule);

            DataColumn IdSubModule = new DataColumn("IdSubModule");
            IdSubModule.DataType = typeof(System.Int32);
            SubModule.Columns.Add(IdSubModule);

            DataColumn descSubModule = new DataColumn("descSubModule");
            descSubModule.DataType = typeof(System.String);
            SubModule.Columns.Add(descSubModule);

            //Interface
            DataColumn IdSubModuleInInterface = new DataColumn("IdSubModuleInInterface");
            IdSubModuleInInterface.DataType = typeof(System.Int32);
            Interface.Columns.Add(IdSubModuleInInterface);

            DataColumn IdInterface = new DataColumn("IdInterface");
            IdInterface.DataType = typeof(System.Int32);
            Interface.Columns.Add(IdInterface);

            DataColumn descInterface = new DataColumn("descInterface");
            descInterface.DataType = typeof(System.String);
            Interface.Columns.Add(descInterface);

            //Method
            DataColumn IdInterfaceInMethod = new DataColumn("IdInterfaceInMethod");
            IdInterfaceInMethod.DataType = typeof(System.Int32);
            Method.Columns.Add(IdInterfaceInMethod);

            DataColumn IdMethod = new DataColumn("IdMethod");
            IdMethod.DataType = typeof(System.Int32);
            Method.Columns.Add(IdMethod);

            DataColumn descMethod = new DataColumn("descMethod");
            descMethod.DataType = typeof(System.String);
            Method.Columns.Add(descMethod);

            DataColumn commentMethod = new DataColumn("commentMethod");
            commentMethod.DataType = typeof(System.String);
            Method.Columns.Add(commentMethod);

            //Return
            DataColumn IdMethodInReturn = new DataColumn("IdMethodInReturn");
            IdMethodInReturn.DataType = typeof(System.Int32);
            Return.Columns.Add(IdMethodInReturn);

            DataColumn IdReturn = new DataColumn("IdReturn");
            IdReturn.DataType = typeof(System.Int32);
            Return.Columns.Add(IdReturn);

            DataColumn descReturn = new DataColumn("descReturn");
            descReturn.DataType = typeof(System.String);
            Return.Columns.Add(descReturn);

            DataColumn ReturnIsList = new DataColumn("ReturnIsList");
            ReturnIsList.DataType = typeof(System.Boolean);
            Return.Columns.Add(ReturnIsList);

            //Parameter
            DataColumn IdMethodInParameter = new DataColumn("IdMethodInParameter");
            IdMethodInParameter.DataType = typeof(System.Int32);
            Parameter.Columns.Add(IdMethodInParameter);

            DataColumn IdParameter = new DataColumn("IdParameter");
            IdParameter.DataType = typeof(System.Int32);
            Parameter.Columns.Add(IdParameter);

            DataColumn descParameter = new DataColumn("descParameter");
            descParameter.DataType = typeof(System.String);
            Parameter.Columns.Add(descParameter);

            DataColumn ParameterIsList = new DataColumn("ParameterIsList");
            ParameterIsList.DataType = typeof(System.Boolean);
            Parameter.Columns.Add(ParameterIsList);

            DataColumn ParameterIsParameter = new DataColumn("ParameterIsParameter");
            ParameterIsParameter.DataType = typeof(System.Boolean);
            Parameter.Columns.Add(ParameterIsParameter);

            DataColumn ParameterType = new DataColumn("ParameterType");
            ParameterType.DataType = typeof(System.String);
            Parameter.Columns.Add(ParameterType);
        }

        public void GenerateEnumAuxiliarSchema()
        {
            Enums = new DataTable("Enums");
            ItensEnums = new DataTable("ItensEnums");

            Authomat.Tables.Add(Enums);
            Authomat.Tables.Add(ItensEnums);
            
            //Enums
            DataColumn IdEnum = new DataColumn("IdEnum");
            IdEnum.DataType = typeof(System.Int32);
            Enums.Columns.Add(IdEnum);

            DataColumn nomeEnum = new DataColumn("nomeEnum");
            nomeEnum.DataType = typeof(System.String);
            Enums.Columns.Add(nomeEnum);

            //ItensEnums
            DataColumn IdEnumInItem = new DataColumn("IdEnumInItem");
            IdEnumInItem.DataType = typeof(System.Int32);
            ItensEnums.Columns.Add(IdEnumInItem);

            DataColumn IdEnumItem = new DataColumn("IdEnumItem");
            IdEnumItem.DataType = typeof(System.Int32);
            ItensEnums.Columns.Add(IdEnumItem);

            DataColumn nomeItemEnum = new DataColumn("nomeItemEnum");
            nomeItemEnum.DataType = typeof(System.String);
            ItensEnums.Columns.Add(nomeItemEnum);
        }

        public void GenerateEntidadeAuxiliarSchema()
        {
            Entidade = new DataTable("Entidade");
            PropriedadesEntidade = new DataTable("PropriedadesEntidade");

            Authomat.Tables.Add(Entidade);
            Authomat.Tables.Add(PropriedadesEntidade);

            //Entidade
            DataColumn IdEntidade = new DataColumn("IdEntidade");
            IdEntidade.DataType = typeof(System.Int32);
            Entidade.Columns.Add(IdEntidade);

            DataColumn nomeEntidade = new DataColumn("nomeEntidade");
            nomeEntidade.DataType = typeof(System.String);
            Entidade.Columns.Add(nomeEntidade);

            DataColumn direcaoEntidade = new DataColumn("direcaoEntidade");
            direcaoEntidade.DataType = typeof(System.Int32);
            Entidade.Columns.Add(direcaoEntidade);

            //Propriedades Entidade
            DataColumn IdEntidadeInProp = new DataColumn("IdEntidadeInProp");
            IdEntidadeInProp.DataType = typeof(System.Int32);
            PropriedadesEntidade.Columns.Add(IdEntidadeInProp);

            DataColumn IdPropriedade = new DataColumn("IdPropriedade");
            IdPropriedade.DataType = typeof(System.Int32);
            PropriedadesEntidade.Columns.Add(IdPropriedade);

            DataColumn nomePropriedade = new DataColumn("nomePropriedade");
            nomePropriedade.DataType = typeof(System.String);
            PropriedadesEntidade.Columns.Add(nomePropriedade);

            DataColumn tipoPropriedade = new DataColumn("tipoPropriedade");
            tipoPropriedade.DataType = typeof(System.String);
            PropriedadesEntidade.Columns.Add(tipoPropriedade);
        }

        public int AddHeader(string ModuleName, string SubModuleName)
        {
            DataRow ModuleNewRow = Module.NewRow();
            int ModuleId = this.SearchNextId("Module");

            ModuleNewRow["IdModule"] = ModuleId;
            ModuleNewRow["descModule"] = ModuleName;

            Module.Rows.Add(ModuleNewRow);

            DataRow SubModuleNewRow = SubModule.NewRow();
            int SubModuleId = this.SearchNextId("SubModule");

            SubModuleNewRow["IdModuleInSubModule"] = ModuleId;
            SubModuleNewRow["IdSubModule"] = SubModuleId;
            SubModuleNewRow["descSubModule"] = SubModuleName;

            SubModule.Rows.Add(SubModuleNewRow);

            return SubModuleId;
        }

        public int AddInterface(string InterfaceName, int SubModuleId)
        {
            DataRow InterfaceNewRow = Interface.NewRow();
            int InterfaceId = this.SearchNextId("Interface");

            InterfaceNewRow["IdSubModuleInInterface"] = SubModuleId;
            InterfaceNewRow["IdInterface"] = InterfaceId;
            InterfaceNewRow["descInterface"] = InterfaceName;

            Interface.Rows.Add(InterfaceNewRow);

            return InterfaceId;
        }

        public int AddMethod(string MethodName, string comment, int InterfaceId)
        {
            DataRow MethodNewRow = Method.NewRow();
            int MethodId = this.SearchNextId("Method");

            MethodNewRow["IdInterfaceInMethod"] = InterfaceId;
            MethodNewRow["IdMethod"] = MethodId;
            MethodNewRow["descMethod"] = MethodName;
            MethodNewRow["commentMethod"] = comment;

            Method.Rows.Add(MethodNewRow);

            return MethodId;
        }

        public void AddReturn(string ReturnName, bool IsList, int MethodId)
        {
            DataRow ReturnNewRow = Return.NewRow();
            int ReturnId = this.SearchNextId("Return");

            ReturnNewRow["IdMethodInReturn"] = MethodId;
            ReturnNewRow["IdReturn"] = ReturnId;
            ReturnNewRow["descReturn"] = ReturnName;
            ReturnNewRow["ReturnIsList"] = IsList;

            Return.Rows.Add(ReturnNewRow);
        }

        public void AddParameter(string ParameterName, bool IsList, int MethodId, bool ParameterIsParameter, string ParameterType)
        {
            DataRow ParameterNewRow = Parameter.NewRow();
            int ParameterId = this.SearchNextId("Parameter");

            ParameterNewRow["IdMethodInParameter"] = MethodId;
            ParameterNewRow["IdParameter"] = ParameterId;
            ParameterNewRow["descParameter"] = ParameterName;
            ParameterNewRow["ParameterIsList"] = IsList;
            ParameterNewRow["ParameterIsParameter"] = ParameterIsParameter;
            ParameterNewRow["ParameterType"] = ParameterType;

            Parameter.Rows.Add(ParameterNewRow);
        }

        public int AddEnum(string nomeEnum)
        {
            DataRow EnumNewRow = Enums.NewRow();
            int EnumId = this.SearchNextId("Enums");

            EnumNewRow["IdEnum"] = EnumId;
            EnumNewRow["nomeEnum"] = nomeEnum;

            Enums.Rows.Add(EnumNewRow);

            return EnumId;
        }

        public void AddEnumItem(string nomeItemEnum, int IdEnumInEnumItem)
        {
            DataRow EnumItemNewRow = ItensEnums.NewRow();
            int EnumItemId = this.SearchNextId("ItensEnums");

            EnumItemNewRow["IdEnumInItem"] = IdEnumInEnumItem;
            EnumItemNewRow["IdEnumItem"] = EnumItemId;
            EnumItemNewRow["nomeItemEnum"] = nomeItemEnum;

            ItensEnums.Rows.Add(EnumItemNewRow);
        }

        public int AddEntidade(string nomeEntidade, Enums.Direction direcaoEntidade)
        {
            DataRow EntidadeNewRow = Entidade.NewRow();
            int EntidadeId = this.SearchNextId("Entidade");

            EntidadeNewRow["IdEntidade"] = EntidadeId;
            EntidadeNewRow["nomeEntidade"] = nomeEntidade;
            EntidadeNewRow["direcaoEntidade"] = (int)System.Enum.Parse(typeof(Enums.Direction), direcaoEntidade.ToString()); ;

            Entidade.Rows.Add(EntidadeNewRow);

            return EntidadeId;
        }

        public void AddPropriedadeEntidade(string nomePropriedadeEntidade, string tipoPropriedadeEntidade, int EntidadeId)
        {
            DataRow PropriedadeEntidadeNewRow = PropriedadesEntidade.NewRow();
            int PropriedadeEntidadeId = this.SearchNextId("PropriedadesEntidade");

            PropriedadeEntidadeNewRow["IdEntidadeInProp"] = EntidadeId;
            PropriedadeEntidadeNewRow["IdPropriedade"] = PropriedadeEntidadeId;
            PropriedadeEntidadeNewRow["nomePropriedade"] = nomePropriedadeEntidade;
            PropriedadeEntidadeNewRow["tipoPropriedade"] = tipoPropriedadeEntidade;

            PropriedadesEntidade.Rows.Add(PropriedadeEntidadeNewRow);
        }

        private int SearchNextId(string pTableName)
        {
            return Authomat.Tables[pTableName].Rows.Count + 1;
        }

        public DataTable returnTable(string pTableName)
        {
            return Authomat.Tables[pTableName];
        }
    }
}
